Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/core/triangulation.rs`:
- Around line 118-120: The import list brings in locate but it's only used in a
debug-only block; wrap the locate import with a debug_assertions cfg so release
builds don't show it as unused (e.g., conditionally import locate when
cfg(debug_assertions)). Keep the other imports (ConflictError, LocateError,
LocateResult, LocateStats, extract_cavity_boundary, find_conflict_region,
locate_by_scan, locate_with_stats) unchanged and only apply the cfg to the
locate symbol referenced in the debug block around the locate usage.
- Around line 5213-5245: The locate_by_scan() retry path currently bypasses the
shared telemetry updater, so increment the scan-fallback counter and record the
locate outcome there: in the code path that calls locate_by_scan() as a retry
(the fallback branch that invokes locate_by_scan()), add
telemetry.locate_scan_fallbacks =
telemetry.locate_scan_fallbacks.saturating_add(1) and then call the common
recorder (e.g., record_locate_telemetry or the helper used elsewhere such as
record_locate_outcome) with the LocateResult and LocateStats from that retry so
locate_calls, locate_walk_steps_*, locate_hint_uses and located_* are accounted
for the scan-retry case as well. Ensure you pass the same InsertionTelemetry,
LocateResult and LocateStats types used by record_locate_telemetry.

In `@src/triangulation/delaunay.rs`:
- Around line 4706-4718: The current match always maps any error from
repair_delaunay_local_single_pass into
TriangulationConstructionError::GeometricDegeneracy; instead, preserve and
propagate internal repair errors untouched so non-retryable failures fail fast.
Update the match on repair_result to: on Ok(()) return Ok(()); on Err(e) if e is
already a DelaunayTriangulationConstructionError (or can be converted from the
underlying repair error) propagate/return that error directly; otherwise wrap
only true geometric degeneracy cases in
TriangulationConstructionError::GeometricDegeneracy as before. Refer to
repair_result, repair_delaunay_local_single_pass,
DelaunayTriangulationConstructionError, and
TriangulationConstructionError::GeometricDegeneracy to locate and implement the
change.

---

Nitpick comments:
In `@src/core/operations.rs`:
- Around line 233-274: The field global_conflict_scan_nanos in struct
InsertionTelemetry is using u128 but should be u64 to match Duration semantics
and save space; change the type of
InsertionTelemetry::global_conflict_scan_nanos from u128 to u64, update any code
that assigns, accumulates, or converts this field (search for references to
InsertionTelemetry and global_conflict_scan_nanos, as well as any
add/extend/Duration::as_nanos() uses) to cast or use as u64 safely, and update
any tests or Default/serialization code that assume u128 accordingly.

In `@src/triangulation/delaunay.rs`:
- Around line 7956-7969: The test currently only verifies ConstructionOptions
getters; add an end-to-end unit test (or extend
test_construction_options_builder_roundtrip) that uses
ConstructionOptions::with_batch_repair_policy(DelaunayRepairPolicy::EveryN(...))
and drives a bulk insertion path so the cadenced repair branch is executed:
construct a builder/triangulation, call the bulk insertion routine that leads to
pending_repair_seeds and then call finalize_bulk_construction, and assert that
repairs occurred at the expected cadence (e.g., by checking pending_repair_seeds
is drained, internal repair count/state, or final triangulation invariants).
Ensure the test references ConstructionOptions, DelaunayRepairPolicy::EveryN,
pending_repair_seeds, and finalize_bulk_construction so the EveryN path is
actually exercised rather than only testing getters.

In `@tests/large_scale_debug.rs`:
- Around line 1180-1206: Add an assertion to test_skip_percentage_reports_ratio
that exercises the total == 0 short-circuit in skip_percentage; e.g., assert
that skip_percentage(0, 0) (or skip_percentage(any, 0)) equals 0.0 using the
same f64::EPSILON comparison pattern so the divide-by-zero branch is covered.
- Around line 346-377: The wildcard arm in initial_simplex_strategy_name should
log unexpected #[non_exhaustive] variants so future additions are visible;
change initial_simplex_strategy_name from const fn to a normal fn (so logging
macros can be used) and add a tracing::debug! (or tracing::warn!) call in the
`_` arm that includes the strategy (or its discriminant/string) before returning
"unknown"; keep initial_simplex_strategy_from_name and
initial_simplex_strategy_from_env behavior unchanged.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/core/triangulation.rs`:
- Around line 4233-4239: The counter/telemetry is being recorded even when
validate_after_insertion(...) only gates and skips real checks; change the
call/site so telemetry (Self::record_topology_validation_telemetry and
incrementing topology_validation_calls) is only invoked when actual validation
work runs. Do this by having validate_after_insertion return a discriminant
(e.g., ValidationOutcome or (bool did_run, Result<(),E>)) or expose a helper
like validation_will_run(...), then: call Instant::now() and record
duration/metric only when did_run is true (i.e., real Level3/link checks
executed). Apply the same change to the other occurrence mentioned (the block
around 4289-4295) so skipped-policy invocations do not increment the validation
counter.

In `@src/triangulation/locality.rs`:
- Around line 18-23: The public wrapper struct LocalConflictSeedCells can be
silently discarded; add the #[must_use] attribute to the LocalConflictSeedCells
declaration so callers get a compiler warning if they ignore the result (leave
the public fields seed_cells: CellKeyBuffer and conflict_cells_found: usize
unchanged). Locate the struct named LocalConflictSeedCells and prepend
#[must_use] directly above its declaration.

---

Outside diff comments:
In `@src/core/triangulation.rs`:
- Around line 5477-5528: The Outside+Some(empty) path is currently treated
differently from Outside+None and loses the terminal_cell-based
repair_seed_cells; modify the (LocateResult::Outside, Some(cells)) branch to
normalize empty buffers by computing repair_seed_cells the same way as the None
branch: if cells.is_empty() then run the same conditional that checks
!locate_stats.fell_back_to_scan() &&
self.tds.contains_cell(locate_trace.terminal_cell) and call
collect_local_exterior_conflict_seed_cells(&self.tds, &self.kernel, &point,
locate_trace.terminal_cell) to produce repair_seed_cells (or
CellKeyBuffer::new() otherwise), then build InsertionSite::Exterior {
conflict_cells: None, repair_seed_cells } so both empty Some and None follow the
identical seed-path; reference LocateResult::Outside,
locate_trace.terminal_cell, collect_local_exterior_conflict_seed_cells,
InsertionSite::Exterior, repair_seed_cells, and CellKeyBuffer.

---

Nitpick comments:
In `@src/triangulation/locality.rs`:
- Around line 51-68: append_live_unique_cell_seeds currently does a linear
seed_cells.contains check per candidate, causing O(n*m) behavior; change it to
build a HashSet (or similar O(1) lookup) from the existing seed_cells once, then
iterate candidate_seed_cells and for each cell_key call
tds.contains_cell(cell_key) and check membership in that set, inserting into
both the set and seed_cells (CellKeyBuffer) when new; also consider reserving
capacity in the set to avoid rehashes. Use the function and variable names
append_live_unique_cell_seeds, seed_cells, candidate_seed_cells, CellKeyBuffer,
CellKey, and tds.contains_cell to locate and update the code.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Nitpick comments:
In `@justfile`:
- Around line 236-237: The recipe debug-large-scale-3d currently defaults
repair_every=2 which diverges from the large-scale harness default of 4; update
the default to repair_every=4 (and likewise update the other occurrence
referenced) or make the parameter optional so the harness default is used, and
ensure any help text/comment near debug-large-scale-3d reflects the new default
to keep behavior and documentation aligned.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@tests/large_scale_debug.rs`:
- Around line 1197-1199: The validation cadence is currently advanced using the
loop index (idx + 1), which moves the schedule for duplicates/degenerate
vertices; change the call to validation_cadence.should_validate to use the count
of successful insertions (e.g., successful_inserts + 1) instead of idx + 1 so
validation is driven by actual mutations, and ensure successful_inserts is only
incremented when a vertex was truly inserted before calling
dt.as_triangulation().is_valid(); update any surrounding logic that assumes
idx-based advancement accordingly.

---

Outside diff comments:
In `@tests/large_scale_debug.rs`:
- Around line 1151-1172: The incremental insertion loop doesn't populate
summary.telemetry or summary.slow_insertions because only attempt/skip counters
are updated; after each insert_with_statistics match arm (both
InsertionOutcome::Inserted and ::Skipped) capture the returned stats and call
the same telemetry/slow-insertion aggregation used by the batch path—e.g. invoke
the summary telemetry/slow-insertion aggregation routines (the same logic used
when converting ConstructionStatistics -> InsertionSummary) inside the Ok((...,
stats)) arms so InsertionSummary (summary.telemetry and summary.slow_insertions)
is updated for ConstructionMode::Incremental as well.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/triangulation/locality.rs`:
- Line 19: This module is declared as pub(crate) so using pub(crate) on items
inside it is redundant; change the visibility of all module-scoped exported
items (e.g., the struct LocalConflictSeedCells and the other pub(crate)
types/functions found in this file) from pub(crate) to pub(super) so they are
exposed only to the parent module as intended; locate each occurrence of
"pub(crate)" in this file and replace it with "pub(super)".

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@benches/ci_performance_suite.rs`:
- Around line 39-41: Add the crate-level attribute to forbid unsafe code by
inserting #![forbid(unsafe_code)] at the very top of the Rust source (before any
items or uses) in this benchmark file; ensure the attribute is the first
non-comment token so it applies to the crate, and run cargo check to confirm no
build issues from the added attribute.

In `@benches/topology_guarantee_construction.rs`:
- Around line 17-19: Add the crate-level attribute to forbid unsafe code by
inserting #![forbid(unsafe_code)] at the very top of the bench file (above the
use/imports) so the file complies with the policy; this affects the module that
imports DelaunayTriangulation, TopologyGuarantee, DelaunayRepairPolicy and
ValidationPolicy and must appear before those use statements.

In `@examples/delaunayize_repair.rs`:
- Around line 21-24: Add the crate-level prohibition by inserting
#![forbid(unsafe_code)] as the very first line of the Rust example file that
contains the Delaunay imports (the file that uses
DelaunayTriangulationConstructionError, DelaunayTriangulationValidationError and
the delaunay::prelude::* modules); this ensures the example conforms to the
Rust-file policy forbidding unsafe code.

In `@examples/numerical_robustness.rs`:
- Around line 12-15: This example file is missing the crate-level attribute that
forbids unsafe Rust; add the declaration `#![forbid(unsafe_code)]` at the very
top of the file (before the `use` statements and any other items) so the
compiler enforces no unsafe code in this example (affects this example
containing DelaunayTriangulation, DelaunayTriangulationConstructionError and
DelaunayTriangulationValidationError).

In `@tests/check_perturbation_stats.rs`:
- Around line 7-11: Add the crate-level attribute forbidding unsafe code to the
top of the file by inserting `#![forbid(unsafe_code)]` as the very first line in
tests/check_perturbation_stats.rs (before the existing `use` statements that
import DelaunayRepairPolicy, DelaunayTriangulation, TopologyGuarantee,
InsertionOutcome, and ValidationPolicy) so the file complies with the
project-wide Rust safety policy.

In `@tests/delaunay_incremental_insertion.rs`:
- Around line 15-17: Add a crate-level ban on unsafe code by inserting
#![forbid(unsafe_code)] at the very top of this test file (before the existing
use declarations that import
delaunay::prelude::triangulation::construction::{ConstructionOptions,
DedupPolicy, DelaunayTriangulation, TopologyGuarantee, vertex, ...}). This will
satisfy the repository policy that every Rust source must explicitly forbid
unsafe code.

In `@tests/euler_characteristic.rs`:
- Around line 17-20: Add the crate-level forbid for unsafe code at the very top
of this test file (before any use/imports) to enforce the project policy; modify
tests/euler_characteristic.rs so that the crate attribute forbidding unsafe code
is present above the existing use
delaunay::prelude::triangulation::construction::{...} import line and ensure it
applies to the whole crate.

---

Outside diff comments:
In `@src/core/algorithms/locate.rs`:
- Line 1: Add the crate-level forbid by inserting the attribute to prohibit
unsafe code at the top of this Rust file: add #![forbid(unsafe_code)] as the
very first item in src/core/algorithms/locate.rs so the module-level policy is
enforced; ensure it appears before any module docs or use/statements so the
compiler applies the ban to all functions/types in this file (e.g., the
point-location functions and any helper structs/enums defined here).

In `@src/core/triangulation.rs`:
- Around line 4129-4168: The telemetry currently conflates full and link-only
validations; update validate_after_insertion so the metrics reflect the
InsertionValidationWork variant returned by
validation_after_insertion_work(suspicion): call
validation_after_insertion_work, log the trigger as now, then in the match arm
for InsertionValidationWork::FullValidation wrap the is_valid() call with the
existing topology_validation_* counters (or increment the existing counters) and
in the InsertionValidationWork::RequiredTopologyLinks arm record a separate pair
of metrics (e.g., topology_link_validation_calls and
topology_link_validation_nanos) or skip touching the existing
topology_validation_* counters if you prefer exclusivity; adjust any uses in
log_validation_trigger_if_enabled/is_valid/validate_required_topology_links if
they currently assume a single metric so telemetry distinguishes full vs
link-only runs.
- Around line 5519-5535: The telemetry call record_conflict_region_telemetry
should not be invoked for caller-provided conflict buffers (the match arm
handling LocateResult::InsideCell(...), Some(cells) where cells came from the
caller); remove or skip that call in these arms and instead either increment a
new provided_conflict_cells/provided_conflict_calls metric or only call
record_conflict_region_telemetry from the code paths that actually perform
discovery (the branches that call find_conflict_region() or
collect_local_exterior_conflict_seed_cells()); update both occurrences (the
InsideCell Some(cells) arm and the analogous branch around lines 5579–5590) to
use ensure_non_empty_conflict_cells for fallback behavior but not count them as
discovered conflict-region telemetry.

---

Duplicate comments:
In `@tests/large_scale_debug.rs`:
- Around line 1198-1200: The validation cadence is advanced using idx + 1 even
when no vertex was actually inserted, causing validation to drift; change the
gating so that you only call validation_cadence.should_validate(...) when this
iteration inserted a vertex (use summary.inserted as the counter rather than idx
+ 1) and only invoke dt.as_triangulation().is_valid() when summary.inserted
indicates a successful insertion this loop; update the condition around
had_cells/validation_cadence.should_validate(...) to check summary.inserted (and
that the current vertex was inserted) before running is_valid().

---

Nitpick comments:
In `@tests/proptest_triangulation.rs`:
- Around line 104-105: The current proptest acceptance uses
prop_assume!(matched_cells > 0) which allows near-vacuous runs; change the
assumption to require multiple matched comparisons (e.g.,
prop_assume!(matched_cells > 1) or prop_assume!(matched_cells >= 2)) and, if
available, also assert the total number of cells considered is >1 so the test
exercises non-trivial triangulation behavior; update the prop_assume! call that
references matched_cells accordingly to ensure the test only accepts cases with
at least two matched cells (and adjust any related counters or variable names
that drive the comparison loop).

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/core/algorithms/flips.rs`:
- Around line 7377-7387: The loop currently hides a missing neighbor by using
`continue` when `tds.cell(neighbor_key)` returns None; instead treat a missing
neighbor as a corruption and fail immediately so caller (e.g.
`build_k3_flip_context*`) sees the real issue. Replace the `continue` in the `if
let Some(neighbor_cell) = tds.cell(neighbor_key) else { continue; };` branch
with an explicit error return (preferably a new descriptive variant like
`FlipError::DanglingRidgeNeighbor { cell_key, neighbor_key }`, or at minimum
return `FlipError::InvalidRidgeAdjacency { cell_key }`) so missing
`neighbor_key` is surfaced rather than turning into an undersized ridge star.
Ensure the error includes `cell_key` and the `neighbor_key` to aid diagnostics.

In `@src/core/triangulation.rs`:
- Around line 5667-5673: The code forces delaunay_repair_required true whenever
caller_provided_conflict_cells is set, which wrongly forces repair for normal
Delaunay/Bowyer‑Watson insertions; change the TryInsertImplOk construction to
use only outcome.delaunay_repair_required (remove the "||
caller_provided_conflict_cells") so insert_with_conflict_region()'s computed
flag is respected; if there is some deliberate external-supplied case that must
force repair, handle that explicitly at the callsite (e.g., in
insert_with_conflict_region or the Delaunay wrapper) rather than OR-ing here.

---

Outside diff comments:
In `@tests/large_scale_debug.rs`:
- Around line 190-230: InsertionSummary's telemetry and slow_insertions are
never populated in incremental mode because record_inserted/record_skipped only
consume InsertionStatistics; either gate telemetry/slow-insertion reporting to
batch mode only (where From<ConstructionStatistics> provides
ConstructionTelemetry) or thread per-insertion telemetry through incremental
paths and accumulate it in record_inserted: modify record_inserted(&mut self,
stats: InsertionStatistics) to accept an additional InsertionTelemetry (or
replace InsertionStatistics with a struct that contains both) and update the
InsertionSummary.telemetry accumulator and slow_insertions vector when an
insertion qualifies; update callers that perform incremental insertions to pass
the telemetry (or add a conversion that builds minimal telemetry from existing
stats) and ensure record_skipped/record continue to call record(...) for
attempt/skips as before.

---

Nitpick comments:
In `@src/core/algorithms/flips.rs`:
- Around line 5123-5143: The silent continue in collect_cells_around_ridge (the
loop that skips when a neighbor cell is missing) can mask broken adjacency;
update that site to either return an explicit error (propagated up to callers
like repair_delaunay_local_single_pass/finalize_bulk_construction) or emit a
debug-level trace with context (ridge id, missing neighbor key) before
continuing so diagnostics are available; ensure this change composes with
verify_local_repair_postcondition/verify_repair_postcondition_with_topology
which uses deferred connectivity during finalize_bulk_construction and does not
assume missing neighbors are benign.

In `@tests/large_scale_debug.rs`:
- Around line 884-981: The new always-on telemetry dump in
print_construction_telemetry (and the similar sections around the
slow_insertions dump) must be gated behind the test diagnostics feature: wrap
the detailed output blocks (the body that calls
print_construction_phase_telemetry, print_timing_summary,
print_local_repair_phase_telemetry, print_local_repair_frontier_telemetry,
print_local_repair_work_telemetry, print_repair_seed_accumulation_telemetry and
the global_conflict_scans printing) in a cfg(feature = "diagnostics")
conditional (or an equivalent test-only gate) so that these summaries only emit
when the "diagnostics" feature is enabled; leave the early has_data() check and
minimal behavior unchanged.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/core/tds.rs`:
- Around line 3599-3620: The helper currently proceeds after computing
mirror_idx without verifying the neighbor's back-reference, allowing
one-way/dangling frontier edges to be accepted; update the helper (the block
using mirror_idx, neighbor_cell, cell, and facet_idx) to check that
neighbor_cell.neighbors()[mirror_idx] equals Some(cell_key) (or otherwise
confirms the back-reference to cell) and if not return an
Err(TdsError::InvalidNeighbors { ... }) (matching the global
validate_coherent_orientation behavior) before computing
facet_vertices_in_cell_order and facet_permutation_parity so scoped adjacencies
cannot silently accept invalid one-way neighbors.

In `@src/core/triangulation.rs`:
- Around line 5331-5341: The returned repair_seed_cells currently only collects
new_cells via append_live_unique_cell_seeds, which omits the actual surviving
frontier produced by local facet repair (neighbor_repair_frontier); update the
code that builds repair_seed_cells before returning CavityInsertionOutcome so it
also appends the neighbor_repair_frontier (using append_live_unique_cell_seeds
or equivalent) so the post-repair frontier is included for follow-up validation
and Delaunay repair; make the same change in the other analogous location
handling CavityInsertionOutcome.
- Around line 4372-4385: The telemetry only records topology validation when
validation_after_insertion_work() returns
InsertionValidationWork::FullValidation, but
validate_after_insertion_with_scope() also performs real link/coherence work for
the RequiredTopologyLinks path; update the conditional(s) that currently match
(Some(InsertionValidationWork::FullValidation), Some(validation_started)) to
also treat InsertionValidationWork::RequiredTopologyLinks as a counted
validation variant (i.e., match both FullValidation and RequiredTopologyLinks),
and call Self::record_topology_validation_telemetry(telemetry,
Self::duration_nanos_saturating(validation_started.elapsed())) in those cases;
apply the same change to the other analogous block that checks for
FullValidation (the second occurrence mentioned).

In `@src/topology/manifold.rs`:
- Around line 483-485: The local pseudomanifold path currently uses bare
VertexKey-based helpers (cell_facet_vertices, facet_incident_handles, and the
facet_to_cells map) so periodic images collapse; update these helpers and all
local validator usages (including validate_local_pseudomanifold_for_cells and
the other occurrences around the indicated ranges) to operate on
lifted/periodic-aware keys: compute facet vertex lists as lifted vertex
identifiers (use the same lifting logic used by the ridge-link path), produce
periodic-aware facet keys, and make facet_incident_handles return incident
handles keyed by those periodic facet keys before inserting into facet_to_cells;
ensure all comparisons and hash/eq uses in
validate_local_pseudomanifold_for_cells and the other noted blocks use the
periodic-key type so distinct images do not merge.

---

Outside diff comments:
In `@src/topology/manifold.rs`:
- Around line 123-152: The lifted_vertex_id function is fabricating
periodic-image IDs as real VertexKey/KeyData values which can collide with other
lifted pairs or actual VertexKey entries; replace this by introducing a
dedicated lifted-vertex identifier type (e.g., LiftedVertexId or
LiftedVertexKey) and use that as the graph key instead of returning VertexKey
from lifted_vertex_id, update all call sites that currently rely on
lifted_vertex_id (search for lifted_vertex_id, VertexKey::from,
KeyData::from_ffi and uses in graph/ridge/link construction and manifold
validation) to accept and store the new type, and remove any logic that inserts
or interprets these synthetic values into slotmap/VertexKey storage so real
VertexKey space remains untouched.

---

Nitpick comments:
In `@docs/archive/issue_341_n1_repair_plan.md`:
- Around line 31-98: The benchmark sections (e.g., "3K 3D, `N=1`" and "10K 3D,
`N=1`" and their three blocks "Before Scoped Post-Insertion Topology
Validation", "After Scoped Post-Insertion Topology Validation", "After Local
Insertion Orientation Validation") lack reproducibility metadata; add a short
metadata header to each benchmark block that includes commit SHA, hardware/CPU
model, build profile (e.g., release/debug, compiler flags), and the exact
command and environment variables used to run the benchmark (shell command and
any relevant ENV like OMP_NUM_THREADS), ensuring the metadata is placed
immediately above the timing list for each of those blocks so readers can
compare results reliably.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Nitpick comments:
In `@src/core/triangulation.rs`:
- Around line 4209-4238: Add a concise scoped-validation contract comment above
the function validate_required_topology_links_for_cells that states the
soundness boundary: list the exact invariants checked (coherent orientation,
local pseudomanifold, ridge-links, geometric cell orientation), explain that
these local checks are sufficient only when topology_guarantee does not require
vertex links and cells is non-empty, and document the explicit fallback
condition that calls validate_required_topology_links() when vertex-link checks
are required or when cells is empty. Also add a numbered citation in
REFERENCES.md (e.g., "1. [author/source]") referencing the relevant algorithmic
source(s) (e.g., Bowyer-Watson, Edelsbrunner, Shewchuk) and include a short note
in the function comment pointing to that REFERENCES.md entry describing the
conditioning and tradeoff between local vs global validation.
- Around line 9937-9964: Add a positive telemetry regression: besides the
existing test
triangulation_policy_skipped_validation_does_not_increment_telemetry, add (or
extend it with) a case where
tri.set_topology_guarantee(TopologyGuarantee::PLManifold) (or use the PLManifold
guarantee) and perform a clean insertion via
insert_with_statistics_seeded_indexed_detailed so that the insertion does real
topology work (the RequiredTopologyLinks path); then assert that
detail.telemetry.topology_validation_calls has incremented (non-zero) for that
PLManifold insertion. Use the same Triangulation, ValidationPolicy::OnSuspicion,
and insert_with_statistics_seeded_indexed_detailed call patterns to mirror the
existing test but assert a positive counter for the PLManifold case.
- Around line 7543-7564: Add dimension-generic pasted tests for D=2..=5
mirroring the existing 3D regressions: create paste-generated test cases for
both the "scoped strict fallback" (based on
test_scoped_strict_validation_falls_back_to_global_vertex_links) and a
"happy-path scoped-validation" test, parameterizing
Triangulation::<FastKernel<f64>, (), (), D>::new_with_tds(...),
validate_after_insertion_with_scope(...), SuspicionFlags::default(),
ValidationPolicy::OnSuspicion and TopologyGuarantee::PLManifoldStrict; adapt or
add generic fixture builders (e.g., build_invalid_vertex_link_tds_<D> or a
generic build_invalid_vertex_link_tds::<D>()) so each pasted test uses the
correct expected_vertex_key for that dimension, and replicate the same
match/assert logic per-dimension to ensure coverage for D=2..=5 (also apply the
same paste expansion to the other related test block around the second reported
range).